package ChessEngine.moveGenerator;

import ChessEngine.moveGenerator.Exceptions.BoardException;
import boardData.*;

import java.util.LinkedList;
//TODO in machen fÃ¤llen Ã¼berspringen figuren gegnerische z.b. wenn davor auch eine steht und diese im vorigen zug geschlagen werden kÃ¶nnte.
//TODO ausfÃ¯Â¿Â½hrlich kommentieren, Methoden kommentare Ã¯Â¿Â½berarbeiten.
//TODO auswahl fÃ¯Â¿Â½r welche farbe die zÃ¯Â¿Â½ge berechnet werden sollen.
//TODO Versuchen die Konstanten aus dem quellcode zu entfernen oder zumindest an einer zentralenstelle zu deklarieren.
//TODO Bessere methode fÃ¯Â¿Â½r Rook und Bishop entwerfen und diese bei Queen anpassen.
//TODO fÃ¯Â¿Â½r queen was Ã¯Â¿Â½berlegen, da sie die selben zÃ¯Â¿Â½ge machen darf wie rook und bishop
//TODO Enpassant und doppelzug bei den bauern implementieren
//TODO ausnahmenbehandlung und exeptions einbauen.
//TODO Mitgelieferte Zeit beachten!
//TODO Testmethoden entfernen.
//TODO code vereinfachen und laufzeit einsparen.
//TODO wenn kÃ¶nig im schach steht nur zÃ¼ge ausgeben mit dennen er aus dem schach befreit werden kann

/**
 * Klasse welche die mÃ¯Â¿Â½glichenzÃ¯Â¿Â½ge generiert, die auf dem momentanen Brett
 * mÃ¯Â¿Â½glich sind.
 * 
 * @author Thomas Rausch
 * @version V0.a.4 (04.08.'11)
 * 
 */
public class MoveGenerator {

	private static final int ONE_FIELD_LEFT  = -1;
	private static final int ONE_FIELD_RIGHT = 1;
	private static final int ONE_FIELD_AHEAD  = 10;
	private static final int ONE_FIELD_BACK = -10;
	private LinkedList<Board> movelist;
	private LinkedList<Integer> pawnlist ;
	
	
//------------------------------Extern aufrufbare Methoden-----------------------------
	public MoveGenerator() {
		// TODO Auto-generated constructor stub
	}
	
	/**
	 * Von aussen aufrufbare Methode , welche die momentan moeglichen zuege fuer das
	 * mitgelieferte Brett und die angegebene Farbe in einer Verketteten Liste
	 * von Boards zurueckliefert.
	 * 
	 * @param board
	 *            Momentanes Spielbrett von welchem ausgehend berechnet werden
	 *            soll.
	 * @param white
	 *            Die Farbe fuer die die zuege berechnet werden sollen.
	 *            fuer Weiss true,
	 *            fuer schwarz false.
	 * @param availableTime
	 *            Die zeit die zur berechnung der moeglichen zuege bereitsteht.
	 * @throws BoardException 
	 */
	public LinkedList<Board> generateMove(Board board, boolean white) throws BoardException  {
		initializeGenerator(board,white);
		scanBoard(board,white);

		return movelist;
	}
//--------------------------Initialisierungsblock-------------------------------------------------
	/**Diese Methode initialisiert den ZugGenerator
	  * @param board
	  * 		  Momentanes Spielbrett von welchem ausgehend berechnet werden
	 *            soll.
	 * @param white
	 *            Die Farbe fuer die die zuege berechnet werden sollen.
	 *            fuer Weiss true,
	 *            fuer schwarz false.
	 * @throws BoardException
	 */
	private void initializeGenerator(Board board, boolean white) throws BoardException {
		pawnlist = new LinkedList<Integer>();
		movelist = new LinkedList<Board>();
		BoardException.ifBoardEmpty(board);
		generatePawnList(white,board);
		
	}
	/**Generiert eine Liste der Bauern, welche noch einen Doppelzug machen duerfen.
	 * @param white
	 * @param board
	 */
	private void generatePawnList(boolean white,Board board) {
		if (white) {
			for (int position = 81; position <= (88); position++) {
				if (board.getPiece(position)==Board.WHITE_PAWN) {
					pawnlist.add(position);
				}				
			}			
		} 
		if (!white) {
			for (int position = 31; position <= (38); position++) {
				if (board.getPiece(position)==Board.BLACK_PAWN) {
					pawnlist.add(position);
				}
			}
		}
		
	}
	//-------------------------------------Moegliche Boards berechnen--------------------------
	/**
	 * Diese Methode durchlauuft das ganze Board,und ruft die entsprechende movefunktion der gefundenen Figuren auf.
	 * 
	 * @param board
	 *            Das Spielbrett welches durchlaufen werden soll.
	 */
	private void scanBoard(Board board,boolean white) {
		//Diese beiden Optionen werden in dieser Methode nicht benÃ¶tigt!
		//Daher false!
		boolean surveyCheck=false;
		boolean colour= false;
		
		for (int currentPosition = 100; currentPosition >= (21); currentPosition--) {
			switch (board.getPiece(currentPosition)) {
//				case Board.EMPTY_FIELD: // Feld leer, ueberspringen mit break;
//					break;
//				case Board.ILLEGAL_FIELD: // Illegales Feld, 
//					break;
				case Board.WHITE_PAWN: // wBauer
					if (white) moveWhitePawn(currentPosition, board);			
					break;
				case Board.WHITE_KNIGHT: // wKnight
					if (white) moveKnight(board, currentPosition, surveyCheck,colour);
					break;
				case Board.WHITE_KING: // wKoenig
					if (white) moveKing(board, currentPosition, surveyCheck,colour);	
					break;
				case Board.WHITE_BISHOP: // wBishop
					if (white) moveBishop(currentPosition, board,surveyCheck,colour);
					break;
				case Board.WHITE_ROOK: // wRook
					if (white) moveRook(currentPosition, board,surveyCheck,colour);
					break;
				case Board.WHITE_QUEEN: // wQueen
					if (white) moveQueen(board, currentPosition,surveyCheck,colour);
					break;
				case Board.BLACK_PAWN: // blBauer
					if (!white) moveBlackPawn(currentPosition, board);
					break;
				case Board.BLACK_KNIGHT: // blKnight
					if (!white) moveKnight(board, currentPosition,surveyCheck,colour);
					break;
				case Board.BLACK_KING: // blKoenig
					if (!white) moveKing(board, currentPosition,surveyCheck,colour);
					break;
				case Board.BLACK_BISHOP: // blBishop
					if (!white) moveBishop(currentPosition, board,surveyCheck,colour);
					break;
				case Board.BLACK_ROOK: // blRook
					if (!white) moveRook(currentPosition, board,surveyCheck,colour);
					break;
				case Board.BLACK_QUEEN: // blQueen
					if (!white) moveQueen(board, currentPosition, surveyCheck,colour);
					break;
					
				default:
					break;
			}		
		}
	}
	
	/**
	 * Diese Funktion haengt die konstruierten Boards mit den moeglichen
	 * Spielzuegen in eine Verkettete Liste ein.
	 * 
	 * @param board
	 *            Spielbrett, welches in die Liste eingehaengt werden soll.
	 */
	private void createBoardObject(Board board) {
		// TODO To String lÃ¯Â¿Â½schen nur zu testzwecken.
		// auch.
		board.toString();
			System.out.println("Wer ist drann:" + board.isSideWhite());
			System.out.println("Wer war drann:" + !board.isSideWhite());
			
			if (!isCheck(board, !board.isSideWhite())) {
				movelist.add(board);
				System.out.println("Anzahl der Boards:"+movelist.size());
			}
			
		
		
	}
	//--------------------------Move Funktionen----------------------------------------------
	
	/**
	 * Diese Funktion berechnet die moeglichen zuege fuer einen Weissen Bauern, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich der Bauer befindet fuer das die moeglichen
	 *            Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem der Bauer steht.
	 */
	private void moveWhitePawn(int currentPosition, Board board) {
		/*
		 * bei i = 9 erfolgt eine ueberpruefung ob die figur links diagonal
		 * ziehen darf bei i=10 erfolgt eine ueberpruefung ob die figur gerade
		 * aus ziehen darf bei i=11 erfolgt eine ueberpruefung ob die figur
		 * rechts diagonal ziehen darf
		 */
		// TODO Enpassant
		//TODO Schwarzer Bauer Ã¤nbdern.
		
		if (isDoubleMovePossible(currentPosition)) {

			if ((isEmptyField(board, currentPosition - 20))
					&&(isEmptyField(board, currentPosition - 10))){
				
				createBoardObject(board.moveClone(currentPosition,
						(currentPosition - 20)));
			}
		}

		for (int i = 9; i <= 11; i++) {
			// evt. Ueberpruefung auf illegal_field ueberfluessig
			if (!isIllegalField(board,currentPosition - i)) {	
				if ((isEmptyField(board, currentPosition -i ) && (i == 10))
						||(!isEmptyField(board, currentPosition -i )&&
						isEnemy(board,currentPosition,currentPosition -i) && (i != 10))) {

					createBoardObject(board.moveClone(currentPosition,(currentPosition - i)));
				}
			}
		}
	}
	
	/**
	 * Diese Funktion berechnet die moeglichen zuege fuer einen Schwarzen Bauern, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich der Bauer befindet fuer das die moeglichen
	 *            Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem der Bauer steht.
	 */
	private void moveBlackPawn(int currentPosition, Board board) {
		/*
		 * bei i = 9 erfolgt eine Ã¯Â¿Â½berprÃ¯Â¿Â½fung ob die figur links diagonal
		 * ziehen darf bei i=10 erfolgt eine Ã¯Â¿Â½berprÃ¯Â¿Â½fung ob die figur gerade
		 * aus ziehen darf bei i=11 erfolgt eine Ã¯Â¿Â½berprÃ¯Â¿Â½fung ob die figur
		 * rechts diagonal ziehen darf
		 */
		
		// TODO Enpassant
		
		if (isDoubleMovePossible(currentPosition)) {

			if ((isEmptyField(board, currentPosition + 20))
					&&(isEmptyField(board, currentPosition + 10))){
				
				createBoardObject(board.moveClone(currentPosition,
						(currentPosition + 20)));
			}
		

		}
		
		for (int i = 9; i <= 11; i++) {
			// evt. Ueberpruefung auf illegal_field ueberfluessig
			if (!isIllegalField(board,currentPosition + i)) {	
				if ((isEmptyField(board, currentPosition + i ) && (i == 10))
						||(isEnemy(board,currentPosition,currentPosition + i) && (i != 10))) {

					createBoardObject(board.moveClone(currentPosition,(currentPosition + i)));
				}
			}
		}
	}
	// Ja wie macht das Pferdschen ? HÃ¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼Ã¼!!!!
	/**
	 * Diese Funktion berechnet die moeglichen zuege fuer ein Pferd, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich das Pferd befindet fuer das die moeglichen
	 *            Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem das Pferd steht.
	 */
	private boolean moveKnight(Board board,int currentPosition,  boolean surveyCheck,boolean colour ) {
		int figure=Board.ILLEGAL_FIELD;
		if (surveyCheck) {
			if (board.giveColour(currentPosition)) {
				figure=Board.WHITE_KNIGHT;
			}
			if (!board.giveColour(currentPosition)) {
				figure=Board.BLACK_KNIGHT;
			}
		}
		
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_RIGHT)+ONE_FIELD_AHEAD),surveyCheck,figure) && surveyCheck) {
	
			return true;
		}
		if (singleMove(board,currentPosition,((2*ONE_FIELD_AHEAD)+ONE_FIELD_LEFT),surveyCheck,figure)&& surveyCheck) {
	
			return true;
		}
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_LEFT)+ONE_FIELD_BACK),surveyCheck,figure) && surveyCheck) {

			return true;
		}
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_RIGHT)+ONE_FIELD_BACK),surveyCheck,figure) && surveyCheck) {
	
			return true;
		}
		
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_AHEAD)+ONE_FIELD_RIGHT),surveyCheck,figure) && surveyCheck) {

			return true;
		}
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_LEFT)+ONE_FIELD_AHEAD),surveyCheck,figure)&& surveyCheck) {
	
			return true;
		}
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_BACK)+ONE_FIELD_LEFT),surveyCheck,figure) && surveyCheck) {
	
			return true;
		}
		if (singleMove(board, currentPosition, ((2*ONE_FIELD_BACK)+ONE_FIELD_RIGHT),surveyCheck,figure) && surveyCheck) {
		
			return true;
		}
		
		//System.out.println("KÃ¶nig steht nicht im Schach");
			
		return false;

	}
	//TODO auf SchachprÃ¼fen
	/**
	 * Diese Funktion berechnet die mÃ¯Â¿Â½glichen zÃ¯Â¿Â½ge fÃ¯Â¿Â½r den KÃ¯Â¿Â½nig, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich der KÃ¯Â¿Â½nig befindet fÃ¯Â¿Â½r den die mÃ¯Â¿Â½glichen
	 *            ZÃ¯Â¿Â½ge ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem der KÃ¯Â¿Â½nig steht.
	 */
	private boolean moveKing( Board board,int currentPosition,boolean surveyCheck,boolean colour) {
		int possiblePosition=currentPosition;
		boolean check=false;
		
		int king=Board.ILLEGAL_FIELD;
		
		if (surveyCheck && colour) {
			king=Board.WHITE_KING;
		}		
		if (surveyCheck && !colour) {
			king=Board.BLACK_KING;
		}
		
		
		for (int i = 9; i <= 11; i++) {
			//grade aus links und rechts diagonal nach vorne!
			possiblePosition=currentPosition+i;
			if (!isIllegalField(board, possiblePosition)) {
				if (isEnemy(board, currentPosition, possiblePosition )
						|| isEmptyField(board, possiblePosition )) {
					
					if (surveyCheck) {
						if (isSpecialEnemy(board, king, possiblePosition)) {
							
							return check=true;
						}
					}else{
						
							createBoardObject(board.moveClone(currentPosition,(possiblePosition)));
						
					}
				}
			}
			//nachhinten  links und rechts diagonal nachhinten!
			possiblePosition=currentPosition-i;
			if (!isIllegalField(board, possiblePosition)) {
				if (isEnemy(board, currentPosition, possiblePosition )
						|| isEmptyField(board, possiblePosition )) {
					
					if (surveyCheck) {
						if (isSpecialEnemy(board, king, possiblePosition)) {
							return check=true;
						}
					}else{
						
							createBoardObject(board.moveClone(currentPosition,(possiblePosition)));
							
					}
					
				}
			}
		}
		if (singleMove(board, currentPosition, ONE_FIELD_LEFT,surveyCheck,king) && surveyCheck) {
	
			return true;
		}
		if (singleMove(board, currentPosition, ONE_FIELD_RIGHT,surveyCheck,king) && surveyCheck) {
	
			return true;
		}
		return check;
	}
	
	/**
	 * Diese Funktion berechnet die moeglichen zuege fuer einen Laeufer, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich der Laeufer befindet fuer den die
	 *            moeglichen Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem der Laeufer steht.
	 */
	//TODO Laufer fÃƒÂ¤llst vom feld debugen und in in dame und turm auch ueberpruefen.

	private boolean moveBishop(int currentPosition, Board board, boolean surveyCheck,boolean colour ) {
		if (multiMove(board, currentPosition, ONE_FIELD_AHEAD+ONE_FIELD_RIGHT,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_AHEAD+ONE_FIELD_LEFT,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_BACK+ONE_FIELD_RIGHT,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_BACK+ONE_FIELD_LEFT,surveyCheck) && surveyCheck) {

			return true;
		}
		
		//System.out.println("KÃ¶nig steht nicht im Schach");
		return false;
		
	}
	
	/**
	 * Diese Funktion berechnet die mueglichen zuege fuer einen Turm, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich der Turm befindet fuer den die moeglichen
	 *            Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem der Turm steht.
	 */
	private boolean moveRook(int currentPosition, Board board, boolean surveyCheck,boolean colour) {

		if (multiMove(board, currentPosition, ONE_FIELD_AHEAD,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_BACK,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_LEFT,surveyCheck) && surveyCheck) {

			return true;
		}
		if (multiMove(board, currentPosition, ONE_FIELD_RIGHT,surveyCheck) && surveyCheck) {

			return true;
		}
		
		//System.out.println("KÃ¶nig steht nicht im Schach");
		return false;
	}
	/**
	 * Diese Funktion berechnet die moeglichen zuege fuer die Dame, auf dem
	 * mitgegebenen Spielbrett unter der angegebenen Position.
	 * 
	 * @param currentPosition
	 *            Position auf der sich die Dame befindet fuer die die moeglichen
	 *            Zuege ermittelt werden sollen.
	 * @param board
	 *            Spielbrett auf dem die Dame steht.
	 */
	private boolean moveQueen(Board board ,int currentPosition , boolean surveyCheck,boolean colour) {
		boolean check=false;
		// Turm bewegung der Dame
		check=moveRook(currentPosition, board,surveyCheck,colour);
		
		//LÃ¤ufer bewegung der Dame
		check=moveBishop(currentPosition, board,surveyCheck,colour);
		
		return check;
	}
	private boolean singleMove(Board board,int currentPosition,int step,boolean surveyCheck, int figure) {
		
		boolean check =false;

		int possiblePosition=currentPosition+step;
				
			if (!isIllegalField(board,possiblePosition)&&isEmptyField(board, possiblePosition)){		
				if (surveyCheck) {
					if (isSpecialEnemy(board, figure, possiblePosition)) {
						
						return check=true;
					}else{
						possiblePosition+=step;
					}
				}else{
					
					createBoardObject(board.moveClone(currentPosition, possiblePosition));
					possiblePosition+=step;
					
				}
							
						
			}else{
				if (!isIllegalField(board,possiblePosition)){
					if (!isEmptyField(board, possiblePosition)&& isEnemy(board, currentPosition, possiblePosition)) {
						if (surveyCheck) {
							if (isSpecialEnemy(board, figure, possiblePosition)) {
								
								return check=true;
							}else{
								possiblePosition+=step;
							}
						}else{
							
							createBoardObject(board.moveClone(currentPosition, possiblePosition));
							possiblePosition+=step;
							
						}
					}
				}
				
			}
			return check;
		}
		
	private boolean multiMove(Board board, int currentPosition, int step, boolean surveyCheck) {
		boolean colour=board.giveColour(currentPosition);
		boolean stop=false;
		boolean check =false;
		
		int possiblePosition=currentPosition+step;
		int figure1=Board.ILLEGAL_FIELD;
		int figure2=Board.ILLEGAL_FIELD;
		//Dann is es en Turm
		if (Math.abs(step)==1||Math.abs(step)==10) {
			if (colour) {
				figure1=Board.WHITE_ROOK;
				figure2=Board.WHITE_QUEEN;
			}
			if (!colour) {
				figure1=Board.BLACK_ROOK;
				figure2=Board.BLACK_QUEEN;
			}
			
		}
		if (Math.abs(step)==11||Math.abs(step)==9) {
			if (colour) {
				figure1=Board.WHITE_BISHOP;
				figure2=Board.WHITE_QUEEN;
			}
			if (!colour) {
				figure1=Board.BLACK_BISHOP;
				figure2=Board.BLACK_QUEEN;
			}
			
		}
		while (!stop) {	
			if (!isIllegalField(board,possiblePosition)&&isEmptyField(board, possiblePosition)){		
				if (surveyCheck) {
					if ((isSpecialEnemy(board, figure1, possiblePosition))||(isSpecialEnemy(board, figure2, possiblePosition))) {
						
						return check=true;
					}else{
						possiblePosition+=step;
					}
				}else{
					
					createBoardObject(board.moveClone(currentPosition, possiblePosition));
					possiblePosition+=step;
					
				}
						
					
			}else{
				if (!isIllegalField(board,possiblePosition)){
					if (!isEmptyField(board, possiblePosition)&& isEnemy(board, currentPosition, possiblePosition)) {
						if (surveyCheck) {
							if ((isSpecialEnemy(board, figure1, possiblePosition))||(isSpecialEnemy(board, figure2, possiblePosition))) {
								
								return check=true;
							}else{
								possiblePosition+=step;
							}
						}else{
							
							createBoardObject(board.moveClone(currentPosition, possiblePosition));
							possiblePosition+=step;
							
						}
					}
				}
				stop=true;
			}
		}
		return check;
	}

	//-------------------------------Auf Schach prÃ¼fen---------------------------------------------
	private boolean isCheck(Board board, boolean colour) {
		
		int king=Board.ILLEGAL_FIELD;
		int pawn=Board.ILLEGAL_FIELD;
		int kingPosition=Board.ILLEGAL_FIELD;
		int field=21;
		
		Boolean surveyCheck = true;
		
		//eigenen KÃ¶nig suchen.
		
		if (colour) {
			king=Board.WHITE_KING;
		}		
		if (!colour) {
			king=Board.BLACK_KING;
		}		
		while (kingPosition==Board.ILLEGAL_FIELD) {
			//System.out.println("jetzige Position" + field);
			if (field<=99) {
				if (board.getPiece(field)==king) {
					//KÃ¶nig wurde gefunden die Untertanen freuen sich ^^
					kingPosition=field;
					System.out.println("KÃ¶nigs position" + kingPosition);
				}
				field++;
			}else{
				//worst case KÃ¶nig is nimme do :)
				//daher sahn ma an der stell enfach mol, genau so gudd wie Schach(Matt ;) ) :P
				System.out.println("----------------------------------------------");
				System.out.println("Koenig steht im Schach");
				System.out.println("----------------------------------------------");
				return true;
			}
			
		}
		
		//Soeoeoeoe eigener Koenig gefunden! 
		//jetzt gugge ma mol ob der von irgend nem Schlingel bedroht wird und ma die Polizei rufe mÃ¼sse ;)
		
		//Auf gegnerische Dame pruefen un ich daet sahn wo ma grad debei sin ach noch uf Laeufer und Turm^^
		if (moveQueen(board, kingPosition, surveyCheck, colour)) {
			System.out.println("----------------------------------------------");
			System.out.println("Koenig steht im Schach");
			System.out.println("----------------------------------------------");
			return true;
		}
		//auf gegnerisches Pferd puefen
		if (moveKnight(board, kingPosition, surveyCheck, colour)) {
			System.out.println("----------------------------------------------");
			System.out.println("Koenig steht im Schach");
			System.out.println("----------------------------------------------");
			return true;
		}
		//pruefen auf generischen KÃ¶nig
		if (moveKing(board, kingPosition, surveyCheck, colour)) {
			System.out.println("----------------------------------------------");
			System.out.println("Koenig steht im Schach");
			System.out.println("----------------------------------------------");
			return true;
		}
		//auf gegnerischen Bauern pruefen
		if (colour) {
			pawn=Board.WHITE_PAWN;
		}		
		if (!colour) {
			pawn=Board.BLACK_PAWN;
		}	
		if ((board.getPiece(kingPosition+9)==pawn)||(board.getPiece(kingPosition+11)==pawn)) {
			System.out.println("----------------------------------------------");
			System.out.println("Koenig steht im Schach");
			System.out.println("----------------------------------------------");
			return true;
		}
		System.out.println("Koenig steht nicht im Schach!!!!!!!!!");
		return false;
			
	}
	//--------------------------Hilfs funktionen-----------------------------------------------
	
	private  boolean isDoubleMovePossible(int currentPosition) {		
		return (-1!=pawnlist.indexOf(currentPosition));
		
	}
	private boolean isIllegalField(Board board, int currentPosition) {
		return (board.getPiece(currentPosition) == Board.ILLEGAL_FIELD);
		
	}
	private boolean isEmptyField(Board board, int currentPosition) {
		return(board.getPiece(currentPosition) == Board.EMPTY_FIELD);
		
	}
	private boolean isEnemy(Board board, int mySelf,int possibleEnemy) {
		return (board.giveColour(mySelf) != board.giveColour(possibleEnemy));
		
	}
	private boolean isSpecialEnemy(Board board, int mySelf,int possibleEnemy) {
		return (mySelf == -board.getPiece(possibleEnemy));
		
	}
	private boolean isOutOfRegularBoard(int i) {
		return (i%10 ==0)||(i%10 ==9);
		
	}


	//----------------------------Main- Wird gelÃ¶scht nur zum testen----------------------------
	
	// TODO Methode nach dem Testen entfernen.
	public static void main(String[] args) throws BoardException {
		/**
		System.out.println("12="+((2*ONE_FIELD_RIGHT)+ONE_FIELD_AHEAD));
		System.out.println("19="+((2*ONE_FIELD_AHEAD)+ONE_FIELD_LEFT));
		System.out.println("-12="+((ONE_FIELD_LEFT+ONE_FIELD_LEFT)+ONE_FIELD_BACK));
		//berichtigt
		System.out.println("-8="+((2*ONE_FIELD_RIGHT)+ONE_FIELD_BACK));
		
		System.out.println("21="+((2*ONE_FIELD_AHEAD)+ONE_FIELD_RIGHT));
		System.out.println("-21="+((ONE_FIELD_BACK+ONE_FIELD_BACK)+ONE_FIELD_LEFT));
		//berichtigt
		System.out.println("-19="+((2*ONE_FIELD_BACK)+ONE_FIELD_RIGHT));
		*/
		//Board board =  Board.giveDefaultBoard();
		MoveGenerator h = new MoveGenerator();
		//System.out.println("SOOO jetzt fange ma an mit dem Brett do\n");
		Board.giveDefaultBoard().toString();
		//System.out.println("un jetzte kumme die berechnete \n");
	    h.generateMove(Board.giveDefaultBoard(), true);

		// System.out.println("-----------------------------------------------");
		// System.out.println("zug machen bauer von d2 auf d3");
		
		//h.generateMove(Board.giveDefaultBoard().moveClone(84, 74), true, 0);

	}

}
